home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / bash-1.12 / dist / builtins / ulimit.def < prev    next >
Encoding:
Text File  |  1992-01-21  |  13.2 KB  |  581 lines
  1. This file is ulimit.def, from which is created ulimit.c.
  2. It implements the builtin "ulimit" in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES ulimit.c
  23.  
  24. $BUILTIN ulimit
  25. $FUNCTION ulimit_builtin
  26. $SHORT_DOC ulimit [-SHacdmstfpn [limit]]
  27. Ulimit provides control over the resources available to processes
  28. started by the shell, on systems that allow such control.  If an
  29. option is given, it is interpreted as follows:
  30.  
  31.     -S    use the `soft' resource limit
  32.     -H    use the `hard' resource limit
  33.     -a    all current limits are reported
  34.     -c    the maximum size of core files created
  35.     -d    the maximum size of a process's data segment
  36.     -m    the maximum resident set size
  37.     -s    the maximum stack size
  38.     -t    the maximum amount of cpu time in seconds
  39.     -f    the maximum size of files created by the shell
  40.     -p    the pipe buffer size
  41.     -n    the maximum number of open file descriptors
  42.  
  43. If LIMIT is given, it is the new value of the specified resource.
  44. Otherwise, the current value of the specified resource is printed.
  45. If no option is given, then -f is assumed.  Values are in 1k
  46. increments, except for -t, which is in seconds, and -p, which is in
  47. increments of 512 bytes.
  48. $END
  49.  
  50. #include <stdio.h>
  51. #include <sys/types.h>
  52. #include <sys/param.h>
  53. #include <errno.h>
  54. #include "../shell.h"
  55. #include "pipesize.h"
  56.  
  57. #if !defined (errno)
  58. extern int errno;
  59. #endif
  60.  
  61. #if defined (HAVE_RESOURCE)
  62. #include <sys/time.h>
  63. #include <sys/resource.h>
  64. #else
  65. #include <sys/times.h>
  66. #endif
  67.  
  68. #if defined (_POSIX_VERSION)
  69. #include <limits.h>
  70. #endif
  71.  
  72. /* Check for the most basic symbols.  If they aren't present, this
  73.    system's <sys/resource.h> isn't very useful to us. */
  74. #if !defined (RLIMIT_FSIZE)
  75. #  undef HAVE_RESOURCE
  76. #endif
  77.  
  78. /* **************************************************************** */
  79. /*                                    */
  80. /*            Ulimit builtin and Hacks.               */
  81. /*                                    */
  82. /* **************************************************************** */
  83.  
  84. /* Block size for ulimit operations. */
  85. #define ULIMIT_BLOCK_SIZE ((long)1024)
  86.  
  87. #define u_FILE_SIZE         0x001
  88. #define u_MAX_BREAK_VAL        0x002
  89. #define u_PIPE_SIZE        0x004
  90. #define u_CORE_FILE_SIZE    0x008
  91. #define u_DATA_SEG_SIZE        0x010
  92. #define u_PHYS_MEM_SIZE        0x020
  93. #define u_CPU_TIME_LIMIT    0x040
  94. #define u_STACK_SIZE        0x080
  95. #define u_NUM_OPEN_FILES    0x100
  96.  
  97. #define u_ALL_LIMITS        0x7ff
  98.  
  99. #ifndef RLIM_INFINITY
  100. #  define RLIM_INFINITY  0x7fffffff
  101. #endif
  102.  
  103. #define LIMIT_HARD 0x01
  104. #define LIMIT_SOFT 0x02
  105.  
  106. static long shell_ulimit ();
  107. static long pipesize ();
  108. static int open_files ();
  109.  
  110. static void print_specific_limits ();
  111. static void print_all_limits ();
  112.  
  113. static char t[2];
  114.  
  115. /* Report or set limits associated with certain per-process resources.
  116.    See the help documentation in builtins.c for a full description.
  117.  
  118.    Rewritten by Chet Ramey 6/30/91. */
  119.  
  120. int
  121. ulimit_builtin (list)
  122.      register WORD_LIST *list;
  123. {
  124.   register char *s;
  125.   int c, setting, cmd, mode, verbose_print, opt_eof;
  126.   int all_limits, specific_limits;
  127.   long current_limit, real_limit, limit = -1L;
  128.   long block_factor;
  129.  
  130.   c = mode = verbose_print = opt_eof = 0;
  131.  
  132.   do
  133.     {
  134.       cmd = setting = all_limits = specific_limits = 0;
  135.       block_factor = ULIMIT_BLOCK_SIZE;
  136.  
  137.       /* read_options: */
  138.       if (list && !opt_eof && *list->word->word == '-')
  139.     {
  140.       s = &(list->word->word[1]);
  141.       list = list->next;
  142.  
  143.       while (*s && (c = *s++))
  144.         {
  145.           switch (c)
  146.         {
  147. #define ADD_CMD(x) { if (cmd) specific_limits++; cmd |= (x); }
  148.  
  149.         case '-':    /* ulimit -- */
  150.           opt_eof++;
  151.           break;
  152.           
  153.         case 'a':
  154.           all_limits++;
  155.           break;
  156.  
  157.         case 'f':
  158.           ADD_CMD (u_FILE_SIZE);
  159.           break;
  160.  
  161. #if defined (HAVE_RESOURCE)
  162.         /* -S and -H are modifiers, not real options.  */
  163.         case 'S':
  164.           mode |= LIMIT_SOFT;
  165.           break;
  166.  
  167.         case 'H':
  168.           mode |= LIMIT_HARD;
  169.           break;
  170.  
  171.         case 'c':
  172.           ADD_CMD (u_CORE_FILE_SIZE);
  173.           break;
  174.  
  175.         case 'd':
  176.           ADD_CMD (u_DATA_SEG_SIZE);
  177.           break;
  178.  
  179. #if !defined (USGr4)
  180.         case 'm':
  181.           ADD_CMD (u_PHYS_MEM_SIZE);
  182.           break;
  183. #endif /* USGr4 */
  184.  
  185.         case 't':
  186.           ADD_CMD (u_CPU_TIME_LIMIT);
  187.           block_factor = 1;    /* seconds */
  188.           break;
  189.  
  190.         case 's':
  191.           ADD_CMD (u_STACK_SIZE);
  192.           break;
  193. #endif /* HAVE_RESOURCE */
  194.  
  195.         case 'p':
  196.           ADD_CMD (u_PIPE_SIZE);
  197.           block_factor = 512;
  198.           break;
  199.  
  200.         case 'n':
  201.           ADD_CMD (u_NUM_OPEN_FILES);
  202.           block_factor = 1;
  203.           break;
  204.  
  205.         default:        /* error_case: */
  206.           t[0] = c;
  207.           t[1] = '\0';
  208.           bad_option (t);
  209. #if !defined (HAVE_RESOURCE)
  210.           builtin_error("usage: ulimit [-afnp] [new limit]");
  211. #else
  212.           builtin_error("usage: ulimit [-SHacmdstfnp] [new limit]");
  213. #endif
  214.           return (EXECUTION_FAILURE);
  215.         }
  216.         }
  217.     }
  218.  
  219.     if (all_limits)
  220.       {
  221.         print_all_limits (mode);
  222.         return (EXECUTION_SUCCESS);
  223.       }
  224.  
  225.     if (specific_limits)
  226.       {
  227.         print_specific_limits (cmd, mode);
  228.         if (list)
  229.           verbose_print++;
  230.         continue;
  231.       }
  232.  
  233.     if (cmd == 0)
  234.       cmd = u_FILE_SIZE;
  235.  
  236.      /* If an argument was supplied for the command, then we want to
  237.        set the limit.  Note that `ulimit something' means a command
  238.        of -f with argument `something'. */
  239.     if (list)
  240.       {
  241.         if (opt_eof || (*list->word->word != '-'))
  242.           {
  243.         s = list->word->word;
  244.         list = list->next;
  245.         if (sscanf (s, "%ld", &limit) != 1)
  246.           {
  247.             if (strcmp (s, "unlimited") == 0)
  248.               limit = RLIM_INFINITY;
  249.             else
  250.               {
  251.             builtin_error ("bad non-numeric arg `%s'", s);
  252.             return (EXECUTION_FAILURE);
  253.               }
  254.           }
  255.         setting++;
  256.           }
  257.         else if (!opt_eof)
  258.           verbose_print++;
  259.       }
  260.  
  261.       if (limit == RLIM_INFINITY)
  262.     block_factor = 1;
  263.  
  264.       real_limit = limit * block_factor;
  265.  
  266.       /* If more than one option is given, list each in a verbose format,
  267.      the same that is used for -a. */
  268.       if (!setting && verbose_print)
  269.     {
  270.       print_specific_limits (cmd, mode);
  271.       continue;
  272.     }
  273.  
  274.       current_limit = shell_ulimit (cmd, real_limit, 0, mode);
  275.  
  276.       if (setting)
  277.     {
  278. #if !defined (HAVE_RESOURCE)
  279.       /* USG systems do not allow limits to be raised by any user
  280.          other than root. */
  281.       if ((current_limit < real_limit) && (getuid () != 0))
  282.         {
  283.           builtin_error ("cannot raise limit: %s", strerror (EPERM));
  284.           return (EXECUTION_FAILURE);
  285.         }
  286. #endif /* !HAVE_RESOURCE */
  287.  
  288.       if (shell_ulimit (cmd, real_limit, 1, mode) == -1)
  289.         {
  290.           builtin_error ("cannot raise limit: %s", strerror(errno));
  291.           return (EXECUTION_FAILURE);
  292.         }
  293.  
  294.       continue;
  295.     }
  296.       else
  297.     {
  298.       if (current_limit != RLIM_INFINITY)
  299.         printf ("%ld\n", (current_limit / block_factor));
  300.       else
  301.         printf ("unlimited\n");
  302.     }
  303.     }
  304.   while (list);
  305.  
  306.   return (EXECUTION_SUCCESS);
  307. }
  308.  
  309. /* The ulimit that we call from within Bash.
  310.  
  311.    WHICH says which limit to twiddle; SETTING is non-zero if NEWLIM
  312.    contains the desired new limit.  Otherwise, the existing limit is
  313.    returned.  If mode & LIMIT_HARD, the hard limit is used; if
  314.    mode & LIMIT_SOFT, the soft limit.  Both may be set by specifying
  315.    -H and -S; if both are specified, or if neither is specified, the
  316.    soft limit will be returned.
  317.  
  318.    Systems without BSD resource limits can specify only u_FILE_SIZE.
  319.    This includes most USG systems.
  320.  
  321.    Chet Ramey supplied the BSD resource limit code. */
  322.  
  323. static long
  324. shell_ulimit (which, newlim, setting, mode)
  325.      int which, setting, mode;
  326.      long newlim;
  327. {
  328. #if defined (HAVE_RESOURCE)
  329.   struct rlimit limit;
  330.   int cmd;
  331.  
  332.   if (mode == 0)
  333.     mode |= LIMIT_SOFT;
  334. #endif
  335.  
  336.   switch (which)
  337.     {
  338. #if !defined (HAVE_RESOURCE)
  339.  
  340.     case u_FILE_SIZE:
  341.       if (!setting)
  342.     {
  343.       /* ulimit () returns a number that is in 512 byte blocks, thus we
  344.          must multiply it by 512 to get back to bytes.  This is false
  345.          only under HP/UX 6.x. */
  346.       long result;
  347.  
  348.       result = ulimit (1, 0L);
  349.  
  350. #  if defined (hpux) && !defined (_POSIX_VERSION)
  351.       return (result);
  352. #  else
  353.       return (result * 512);
  354. #  endif /* hpux 6.x */
  355.     }
  356.       else
  357.     return (ulimit (2, newlim / 512L));
  358.  
  359.       break;
  360.  
  361. #else /* defined (HAVE_RESOURCE) */
  362.  
  363.     case u_FILE_SIZE:
  364.       cmd = RLIMIT_FSIZE;
  365.       goto do_ulimit;
  366.  
  367.     case u_CORE_FILE_SIZE:
  368.       cmd = RLIMIT_CORE;
  369.       goto do_ulimit;
  370.  
  371.     case u_DATA_SEG_SIZE:
  372.       cmd = RLIMIT_DATA;
  373.       goto do_ulimit;
  374.  
  375. #if !defined (USGr4)
  376.     case u_PHYS_MEM_SIZE:
  377.       cmd = RLIMIT_RSS;
  378.       goto do_ulimit;
  379. #endif /* USGr4 */
  380.  
  381.     case u_CPU_TIME_LIMIT:
  382.       cmd = RLIMIT_CPU;
  383.       goto do_ulimit;
  384.  
  385.     case u_STACK_SIZE:
  386.       cmd = RLIMIT_STACK;
  387.  
  388.     do_ulimit:
  389.  
  390.       if (getrlimit (cmd, &limit) != 0)
  391.     return ((long) -1);
  392.  
  393.       if (!setting)
  394.     {
  395.       if (mode & LIMIT_SOFT)
  396.         return (limit.rlim_cur);
  397.       else
  398.         return (limit.rlim_max);
  399.     }
  400.       else
  401.     {
  402.       if (mode & LIMIT_SOFT)
  403.         limit.rlim_cur = newlim;
  404.       if (mode & LIMIT_HARD)
  405.         limit.rlim_max = newlim;
  406.  
  407.       return (setrlimit (cmd, &limit));
  408.     }
  409.  
  410.       break;
  411.  
  412. #endif /* HAVE_RESOURCE */
  413.  
  414.       /* You can't get or set the pipe size with getrlimit, so we have to
  415.      cheat.  */
  416.     case u_PIPE_SIZE:
  417.       if (setting)
  418.     {
  419.       errno = EINVAL;
  420.       return ((long) -1);
  421.     }
  422.       return (pipesize ());
  423.  
  424.     case u_NUM_OPEN_FILES:
  425.       if (setting)
  426.     {
  427. #if defined (HAVE_RESOURCE) && defined (RLIMIT_NOFILE)
  428.       cmd = RLIMIT_NOFILE;
  429.       goto do_ulimit;
  430. #else
  431. #  if defined (HAVE_SETDTABLESIZE)
  432.       return (setdtablesize (newlim));
  433. #  else
  434.       errno = EINVAL;
  435.       return ((long) -1);
  436. #  endif /* HAVE_SETDTABLESIZE */
  437. #endif /* !HAVE_RESOURCE || !RLIMIT_NOFILE */
  438.     }
  439.       else
  440.     return ((long) open_files (mode));
  441.  
  442.     default:
  443.       errno = EINVAL;
  444.       return ((long) -1);
  445.     }
  446. }
  447.  
  448. static int
  449. open_files (mode)
  450.      int mode;
  451. {
  452. #if !defined (RLIMIT_NOFILE)
  453.   return (getdtablesize ());
  454. #else
  455.   struct rlimit rl;
  456.  
  457.   getrlimit (RLIMIT_NOFILE, &rl);
  458.   if (mode & LIMIT_SOFT)
  459.     return (rl.rlim_cur);
  460.   else
  461.     return (rl.rlim_max);
  462. #endif
  463. }
  464.  
  465. static long
  466. pipesize ()
  467. {
  468. #if defined (PIPE_BUF)
  469.   /* This is defined on Posix systems. */
  470.   return ((long) PIPE_BUF);
  471. #else
  472. #  if defined (PIPESIZE)
  473.   /* This is defined by running a program from the Makefile. */
  474.   return ((long) PIPESIZE);
  475. #  else
  476.   errno = EINVAL;
  477.   return ((long) -1);
  478. #  endif /* PIPESIZE */
  479. #endif /* PIPE_BUF */
  480. }
  481.  
  482. /* ulimit(2) returns information about file size limits in terms of 512-byte
  483.    blocks.  This is the factor by which to divide to turn it into information
  484.    in terms of 1024-byte blocks.  Except for hpux 6.x, which returns it in
  485.    terms of bytes. */
  486. #if !defined (hpux) || defined (_POSIX_VERSION)
  487. #  define ULIMIT_DIVISOR 2
  488. #else
  489. #  define ULIMIT_DIVISOR 1024
  490. #endif
  491.  
  492. #if defined (HAVE_RESOURCE)
  493.  
  494. #if !defined (RLIM_NLIMITS)
  495. #  define RLIM_NLIMITS 6    /* Number of resource limits. */
  496. #endif
  497.  
  498. typedef struct {
  499.   int  option_cmd;        /* The ulimit command for this limit. */
  500.   int  parameter;        /* Parameter to pass to getrlimit (). */
  501.   int  block_factor;        /* Blocking factor for specific limit. */
  502.   char *description;        /* Descriptive string to output. */
  503. } BSD_RESOURCE_LIMITS;
  504.  
  505. static BSD_RESOURCE_LIMITS limits[RLIM_NLIMITS + 1] = {
  506.   { u_CORE_FILE_SIZE, RLIMIT_CORE,  1024, "core file size (blocks)" },
  507.   { u_DATA_SEG_SIZE,  RLIMIT_DATA,  1024, "data seg size (kbytes)" },
  508.   { u_FILE_SIZE,      RLIMIT_FSIZE, 1024, "file size (blocks)" },
  509. #if !defined (USGr4)
  510.   { u_PHYS_MEM_SIZE,  RLIMIT_RSS,   1024, "max memory size (kbytes)" },
  511. #endif /* USGr4 */
  512.   { u_STACK_SIZE,     RLIMIT_STACK, 1024, "stack size (kbytes)" },
  513.   { u_CPU_TIME_LIMIT, RLIMIT_CPU,      1, "cpu time (seconds)" },
  514.   { 0, 0, 0, (char *)NULL }
  515. };
  516.  
  517. static void
  518. print_bsd_limit (i, mode)
  519.      int i, mode;
  520. {
  521.   struct rlimit rl;
  522.   long limit;
  523.  
  524.   getrlimit (limits[i].parameter, &rl);
  525.   if (mode & LIMIT_HARD)
  526.     limit = rl.rlim_max;
  527.   else
  528.     limit = rl.rlim_cur;
  529.   printf ("%-25s", limits[i].description);
  530.   if (limit == RLIM_INFINITY)
  531.     printf ("unlimited\n");
  532.   else
  533.     printf ("%ld\n", limit / limits[i].block_factor);
  534. }
  535.  
  536. static void
  537. print_specific_bsd_limits (cmd, mode)
  538.      int cmd, mode;
  539. {
  540.   register int i;
  541.  
  542.   for (i = 0; limits[i].option_cmd; i++)
  543.     if (cmd & limits[i].option_cmd)
  544.       print_bsd_limit (i, mode);
  545. }
  546. #endif /* HAVE_RESOURCE */
  547.  
  548. /* Print the limits corresponding to a specific set of resources.  This is
  549.    called when an option string contains more than one character (e.g. -at),
  550.    because limits may not be specified with that kind of argument. */
  551. static void
  552. print_specific_limits (cmd, mode)
  553.      int cmd, mode;
  554. {
  555.   if (mode == 0)
  556.     mode |= LIMIT_SOFT;
  557.  
  558. #if defined (HAVE_RESOURCE)
  559.   print_specific_bsd_limits (cmd, mode);
  560. #else
  561.   if (cmd & u_FILE_SIZE)
  562.     printf ("%-25s%ld\n", "file size (blocks)", ulimit (1, 0L) / ULIMIT_DIVISOR);
  563. #endif
  564.  
  565.   if (cmd & u_PIPE_SIZE)
  566.     printf ("%-25s%ld\n", "pipe size (512 bytes)", (pipesize () / 512));
  567.  
  568.   if (cmd & u_NUM_OPEN_FILES)
  569.     printf ("%-25s%ld\n", "open files", open_files (mode));
  570. }
  571.  
  572. static void
  573. print_all_limits (mode)
  574.      int mode;
  575. {
  576.   if (mode == 0)
  577.     mode |= LIMIT_SOFT;
  578.  
  579.   print_specific_limits (u_ALL_LIMITS, mode);
  580. }
  581.